W lekcji Volley , Google instruuje, aby dodać Volley do naszego projektu jako projekt biblioteki Androida lub jako plik .jar.

Oto jak stworzyć plik .jar używając Android Studio lub Eclipse :

Uwaga:

W obu przypadkach proponuję zmienić nazwę pliku .jar Na datę najnowszego commita, tj. volley_20150319.jar, aby wersjonowanie było proste.

Android Studio:

1. Clone the Repozytorium Volley via Git.
2. zaimportuj projekt do Android Studio. (Zwykle wybieram plik gradle projektu podczas importowania w Android Studio)
3. Zbuduj projekt. (Musiałem zmienić ustawienia gradle build, aby odzwierciedlić najnowsze narzędzia do budowania i wersję gradle, ale zwykle jest ona aktualna).
4. w Eksploratorze plików przejdź do [your local path to volley]/build/intermediate/bundles/
5. w folderach debug i release znajdziesz plik JAR o nazwie classes.jar.
6. skopiuj plik JAR do swojego libs/ folder.
Gradle sync i gotowe.

Zaćmienie:

1. Sklonuj repozytorium Volley poprzez Git.
2. Importuj projekt do eclipse.
3. kliknij prawym przyciskiem myszy projekt i wybierz Eksportuj...
4. Wybierz plik Java / jar.
5. interesuje nas tylko folder src i nic więcej. Najprostszym sposobem, aby upewnić się, że tylko on jest zaznaczony, jest odznaczenie projektu, a następnie zaznaczenie src folder wewnątrz.
6. zaznacz opcję Eksportuj wygenerowane pliki klas i zasoby.
7. opcjonalne: jeśli chcesz, aby Javadoc był widoczny również Wybierz Export Java source files resources .
8. Utwórz plik JAR i umieść go w swoim folderze libs/.

1) Czy ta biblioteka może być również używana jako biblioteka sieciowa w normalnych projektach Java, czy tylko dla Androida

2) widzę tu wiele gałęzi i brak dokumentacji, od której gałęzi należy zacząć. Od której gałęzi powinienem zacząć?

Instrukcje z Google i / o presentation miały po prostu sklonować repo git, które domyślnie pobierałoby z gałęzi master.

3) jak zintegrować tę bibliotekę z własnym projektem? Jakie podejście jest lepsze: zrobić Volley jako samodzielny projekt biblioteki i zakręcić jar i umieścić go w swoim projekcie lub skopiować cały kod źródłowy wewnątrz projektu?

Instrukcje z Prezentacji Google I / O polegały na dodaniu kodu źródłowego do twojego projektu. Osobiście uważam to za dziwaczne podejdźcie.

Możesz pobrać .jar

Źródło: AndroidHive

SkopiujVolley.jar do libs

Then

Kliknij Prawym Przyciskiem Myszy volley.jar -> Dodaj Jako Bibliotekę

Biblioteka Volley jest obecnie publikowana przez Android Open Source Project:

dependencies {
    implementation 'com.android.volley:volley:1.1.0'
}

UPDATE: Volley jest teraz oficjalna i jest dostępna za pośrednictwem JCenter. Oto jak go zaimportować:

compile 'com.android.volley:volley:1.0.0'

DEPRECATED WAY:

Jeśli używasz Gradle, możesz zaimportować Volley z tutaj .

dependencies {
    compile 'com.mcxiaoke.volley:library:1.0.+'
}

Uwaga

Jest to nieoficjalne lustro (z drobnymi poprawkami, zobacz Changelog Po szczegóły.) dla biblioteki Androida , kod źródłowy będzie okresowo synchronizowany z oficjalny skład volley.

Wiele sposobów

Dodaj go jako bibliotekę - (szybkie rozwiązanie)

1. pobierz go z: androidhive
2. umieść go w swoim [MyProjectPath]/app/libs/ folderze
3. W Android Studio right-click na nim i wybierz Add As Library...

Źródło pliki z git - (raczej oficjalne rozwiązanie)

1. Pobierz / zainstaluj Git client (jeśli nie masz go jeszcze w swoim systemie) (innevise via git clone https://github.com/git/git ... sry zły, ale nie mogłem się oprzeć ^^)
2. wykonaj git clone https://android.googlesource.com/platform/frameworks/volley

3. Skopiuj folder com z wewnątrz [path_where_you_typed_git_clone]/volley/src do folderu projektów app/src/main/java (lub Zintegruj go, jeśli masz już folder com!! ;-))

   Pliki pojawiają się natychmiast w Android Studio. For Eclipse you będzie musiał right-click w folderze src i najpierw nacisnąć refresh (lub F5).

   Robienie tego przez git jest tym, co jest oficjalnie sugerowane w samouczkach Androida ( spójrz tutaj ).

Gradle przez "nieoficjalne" lustro - (rozwiązanie dynamiczne)

1. W pliku src/build.gradle twojego projektu dodaj następującą zależność:

       dependencies {
           compile fileTree(dir: 'libs', include: ['*.jar'])
           // ...
   
           compile 'com.mcxiaoke.volley:library:1.+'
       }
   

2. Kliknij na Try Again, który powinien od razu pojawić się na górze pliku, lub po prostu Build jeśli Nie

   Główną "zaletą" jest to, że dzięki temu wersja będzie dla Ciebie aktualna, podczas gdy w pozostałych dwóch przypadkach będziesz musiał ręcznie aktualizować volley.

   Na "minusie" to nie jest oficjalnie od google, ale trzecia strona cotygodniowe lustro.

   Ale oba te punkty są naprawdę związane z tym,czego potrzebujesz / chcesz. Również jeśli nie chcesz aktualizacji, po prostu umieść tam żądaną wersję, np. compile 'com.mcxiaoke.volley:library:1.0.7'.

Jeśli używasz GIT do zarządzania własnym kodem, dlaczego nie dodać go jako podmodule do projektu...

git submodule add https://android.googlesource.com/platform/frameworks/volley -b master Volley

W ten sposób, gdy baza kodu jest aktualizowana, jest to proste do aktualizacji...

git submodule git pull

Możesz rozszerzyć główną klasę Volley w swoim własnym projekcie do modyfikacji, co pozwala uniknąć bałaganu z kodowaniem zmian za każdym razem, gdy Volley framework jest aktualizowany.

Oto mały Quickstart dla żądania Http, jest niezwykle łatwy do integracji.

• Potrzebna jest szeroka aplikacja RequestQueue:

  1. private static RequestQueue reqQueue;
  

Możesz umieścić go w swojej klasie aplikacji i udostępnić statycznie za pomocą getRequestQueue ().

• Wtedy możesz już użyć RequestQueue.metoda add() do wykonania pierwszego żądania za pomocą Volley.

  2. reqQueue.add(...)
  

• Użyj JsonObjectRequest, aby wyszukać pojedynczy obiekt, użyj JsonArrayRequest, aby wyszukać listę obiektów.

  queue.add(new JsonArrayRequest(URL, new Listener<JSONArray>() {
  
      @Override
      public void onResponse(JSONArray response) {
          //SUCCESS
      }}, new ErrorListener() {
  
      @Override
      public void onErrorResponse(VolleyError error) {
          //ERROR
      }}));
  

• Pamiętaj, aby poprawnie ustawić nagłówek HTTP Expires po stronie serwera, aby móc korzystać z wbudowanej funkcji buforowania

Tutaj inny sposób z Android Studio ang Gradle:

Potrzebujesz następnego w swojej konstrukcji.gradle projektu (na poziomie struktury aplikacji):

repositories {
    maven {
        url 'https://github.com/Goddchen/mvn-repo/raw/master/'
    }
    mavenCentral()
}

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    // You must install or update the Support Repository through the SDK manager to use this dependency.
    compile 'com.android.support:support-v4:20.+'
    compile 'com.android:volley:1.+'
}

Najpierw Sklonuj projekt z Git

$git clone https://android.googlesource.com/platform/frameworks/volley

• import volley w eclipse.
• Kliknij prawym przyciskiem myszy na swoim projekcie-> właściwość - > android
• Dodaj bibliotekę - > wybierz (jeśli nie widzisz tam volley, rigth kliknij volley library, goto property i android i kliknij bibliotekę)
• po dodaniu volley jako biblioteki możesz zacząć używać jej w swojej aplikacji.

Jakaś podstawowa klasa siatkówki, którą powinieneś znać are

• RequestQueue
• JsonArrayRequest
• JsonObjectRequest

Aby użyć volley najpierw musisz utworzyć obiekt RequestQueue

RequestQueue mQueue = Volley.newRequestQueue(getApplicationContext());

Second - > make a Request using either JsonArrayRequest or JsonObjectRequest

JsonArrayRequest mJsonRequest = new JsonArrayRequest(url, 
            new Listener<JSONArray>() {

                @Override
                public void onResponse(JSONArray response) {
                    // here you can parse response and use accordingly
                }
            }, new ErrorListener() {

                @Override
                public void onErrorResponse(VolleyError error) {
                    // here you will receive errors and show proper message according to error type

                }
            });

I w końcu umieścić żądanie w kolejce. tj.

mQueue.add(mJsonRequest);

Dodanie Volley jar (lub dowolnego jar) do Android Studio 1.0.2 jest teraz znacznie łatwiejsze. Poza Android Studio skopiuj volley.jar do <yourproject>/app/libs (który powinien już istnieć). Ponieważ domyślna konfiguracja Gradle zawiera tę linię:

 compile fileTree(dir: 'libs', include: ['*.jar'])

... wszystko jest gotowe. Może się tak nie wydawać, ponieważ domyślny widok struktury projektu (File -> Project Structure) nie pokazuje katalogu libs. Aby go zobaczyć, musisz użyć spinnera tuż nad widokiem struktury projektu, aby zmienić Android na Project.

Możesz zobaczyć, że to działa, budując aplikację( może nie być konieczne), a następnie zaczynając wpisywać jakiś kod w ten sposób:

 RequestQueue request

Zobaczysz, że Android Studio wyświetli monit o zakończenie RequestQueue (com.android.volley).

Its również dość łatwo uzyskać debugowania AAR zbudowany, jeśli to twoje preferencje.

git clone https://android.googlesource.com/platform/frameworks/volley

Następnie utwórz nowy projekt Android studio (zwykły projekt aplikacji) w innym katalogu. Po zakończeniu Dodaj nowy podmoduł (Plik / Nowy Moduł). Wybierz opcję Importuj istniejący projekt i skieruj go do katalogu, w którym się wypisałeś. Gdy to zrobisz, możesz stworzyć swój moduł i utworzy on plik aar.

Używając eclipse Luna musisz:

• Sklonuj go z Gita.
• Wytnij (skopiuj i usuń) folder COM pod folderem JAVA do folderu SRC, jak w zwykłym projekcie Android.
• Zmień projekt.właściwości docelowe do 15 zamiast 8.
• Zbuduj projekt.
• Eksportuj projekt jako plik jar wraz ze źródłem-użyj narzędzia export.
• zachowaj w wyeksportowanym jar tylko folder COM i folder META-INF, usuń wszystkie pozostałe foldery-użyj narzędzie zip do usuwania zawartości jar.
• Użyj tego słoika jako swojego projektu Volley jar.
• umieść słoik Volley w folderze lib docelowego projektu Android.

Jeśli używasz Android Studio, co powinieneś zrobić, umieść tę linię w pliku gradle

compile 'com.mcxiaoke.volley:library:1.0.15'

Jeśli chcesz użyć metody GET, powinieneś mieć coś takiego.

private void weatherData() {
    JsonObjectRequest jsonObjReq = new JsonObjectRequest(
        Request.Method.GET,
        "URL with JSON data",
        new Response.Listener<JSONObject>() {
             @Override
             public void onResponse(JSONObject response) {
                 try {
                      //Your code goes here      
                 } catch (JSONException e) {
                      Log.e("TAG", e.toString());
                 }
             }
        }, 
        new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
            }
        });
    // Adding request to request queue
    AppController.getInstance().addToRequestQueue(jsonObjReq);
}

Ale jeśli chcesz opublikować dane na serwerze, powinieneś skonstruować Hashmapę i bibliotekę Volley konwertuje te wartości klucza/pary do obiektów JSON przed opublikowaniem ich na serwerze. Oto przykład.

final HashMap<String, String> postParams = new HashMap<String, String>();
postParams.put("username", username);
postParams.put("password", password);

Response.Listener<JSONObject> listener;
Response.ErrorListener errorListener;
final JSONObject jsonObject = new JSONObject(postParams);

JsonObjectRequest jsonObjReq = new JsonObjectRequest(
    "YOUR URL WITH JSON DATA", 
    jsonObject,
    new com.android.volley.Response.Listener<JSONObject>() {
        @Override
        public void onResponse(JSONObject response) {
            Log.d("TAG", response.toString());
            try {
                if (response.getString("status").equals("fail")) {

                } else if (response.getString("status").equals("success")) {

                } catch (JSONException e) {
                     Log.e("TAG", e.toString())
                }
            }
        }, 
        new com.android.volley.Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
             //VolleyLog.d("TAG", "Error: " + error.getMessage());
            //pDialog.dismiss();

        }
    }) {
        @Override
        public String getBodyContentType() {
            return "application/json; charset=utf-8";
        }
    };
    // Adding request to request queue
    AppController.getInstance().addToRequestQueue(jsonObjReq, tag_json_obj);

    VolleySingleton.getInstance(getApplicationContext()).
    addToRequestQueue(jsonObjRequest);
 }

Sklonowałem projekt Volley i dodałem pliki konfiguracyjne, które pozwalają na budowanie biblioteki z Gradle.

• Gradle gotowy klon Google Android

Dzięki temu możesz zainstalować bibliotekę w lokalnym repozytorium Maven i odwoływać się do niej z projektu Android za pośrednictwem Gradle.

Wymagania

1. Maven
2. Gradle

Jak używać

1. klon moje repozytorium
2. budować i zainstaluj bibliotekę Volley
[[5]}odwołaj się do biblioteki w projekcie Android

Poprawki błędów

Proszę pamiętać, że istnieją różne klony, które mają ulepszenia dla biblioteki. Może być konieczne ich zintegrowanie i skompilowanie prywatnej rozszerzonej wersji biblioteki.

Korzyści

Oprócz samej biblioteki skrypt build generuje JavaDoc i archiwa źródeł.

Napotkałem problem, gdy biblioteka wsparcia była wymieniona w drugiej linii. Zmiana kolejności tych dwóch wypowiedzi zadziałała dla mnie.

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile 'com.mcxiaoke.volley:library:1.0.6'
    compile 'com.android.support:support-v4:20.+'
}

Volley może być dodany jako submodule git w bieżącym repo projektu. Ten podmoduł Gita wskaże oficjalny repo Gita Volley. Dlatego możesz uzyskać aktualizacje z oficjalnego repo git poprzez aktualizację podmodułu pointer.

Jeszcze więcej jeśli dodasz Volley jako moduł biblioteki w swoim głównym projekt można łatwo dostosować go. Będzie bardzo przydatny do debugowania cel również.

Aby to osiągnąć, wykonaj następujące kroki:

Etap I :

Dodaj volley jako submodule w projekcie aplikacji na Androida GIT Repo. git submodule add-B master https://android.googlesource.com/platform/frameworks/volley Biblioteki / Volley

Etap II:

W Ustawieniach.gradle, dodaj poniższy moduł do projektu studyjnego. include ': Volley' projekt ( ': Volley').projectDir = new File ('../ Biblioteki / Volley')

Krok III:

W app / build.gradle, Dodaj następujący wiersz do Kompilacje compile project (': Volley')

Za każdym razem, gdy chcesz uzyskać najnowszy kod z Google official Po prostu uruchom poniższe polecenie

git submodule foreach git pull

Aby uzyskać bardziej szczegółowe informacje : https://gitsubmoduleasandroidtudiomodule.blogspot.in/

Git Repo przykładowy kod: https://github.com/arpitratan/AndroidGitSubmoduleAsModule

Dla Przyszłych Czytelników

Dostarcza ConnectionManager.class, w której dostępne są różne metody dlaVolley String iVolley JSON . Możesz składać wnioski z GET, PUT, POST, Usuń z nagłówkiem lub bez. Możesz przeczytać pełną dokumentację tutaj .

Zależności {

   compile 'io.gloxey.gnm:network-manager:1.0.1'

}